// SymbolicEngine.pas
unit SymbolicEngine;

interface

uses
  SysUtils, Classes, DataUtils, ucs4unit;

type
  TFact = record
    Subject: string;
    Relation: string;
    Object: string;
    Confidence: Double;
  end;

  TRule = record
    Condition: string; // Логическое выражение
    Action: string;    // Действие/вывод
    Priority: Integer;
  end;

  TSymbolicEngine = class
  private
    FFacts: array of TFact;
    FRules: array of TRule;
    FWorkingMemory: TStringList;
  public
    constructor Create;
    destructor Destroy; override;
    
    procedure AddFact(const Subject, Relation, Object: string; Confidence: Double = 1.0);
    procedure AddRule(const Condition, Action: string; Priority: Integer = 1);
    
    function Infer(const Query: string): TFact;
    function ExecuteRule(const Input: string): string;
    
    procedure SaveToFile(const Filename: string);
    procedure LoadFromFile(const Filename: string);
  end;

implementation

constructor TSymbolicEngine.Create;
begin
  inherited;
  FWorkingMemory := TStringList.Create;
  SetLength(FFacts, 0);
  SetLength(FRules, 0);
  
  // Базовые правила
  AddRule('Contains(Input, "привет")', 'Greeting', 10);
  AddRule('Contains(Input, "пока")', 'Farewell', 10);
  AddRule('Contains(Input, "?") AND Length(Input) > 5', 'Question', 5);
end;

destructor TSymbolicEngine.Destroy;
begin
  FWorkingMemory.Free;
  inherited;
end;

procedure TSymbolicEngine.AddFact(const Subject, Relation, Object: string; Confidence: Double);
begin
  SetLength(FFacts, Length(FFacts) + 1);
  with FFacts[High(FFacts)] do
  begin
    Subject := Subject;
    Relation := Relation;
    Object := Object;
    Confidence := Confidence;
  end;
end;

procedure TSymbolicEngine.AddRule(const Condition, Action: string; Priority: Integer);
begin
  SetLength(FRules, Length(FRules) + 1);
  with FRules[High(FRules)] do
  begin
    Condition := Condition;
    Action := Action;
    Priority := Priority;
  end;
end;

function TSymbolicEngine.ExecuteRule(const Input: string): string;
var
  I: Integer;
  LowerInput: string;
begin
  Result := '';
  LowerInput := UTF8LowerCase(Input);
  
  // Применяем правила в порядке приоритета
  for I := 0 to High(FRules) do
  begin
    if FRules[I].Condition = 'Contains(Input, "привет")' then
    begin
      if LowerInput.Contains('привет') or LowerInput.Contains('здравств') then
      begin
        Result := 'Greeting';
        Exit;
      end;
    end
    else if FRules[I].Condition = 'Contains(Input, "пока")' then
    begin
      if LowerInput.Contains('пока') or LowerInput.Contains('до свидан') then
      begin
        Result := 'Farewell';
        Exit;
      end;
    end
    else if FRules[I].Condition = 'Contains(Input, "?") AND Length(Input) > 5' then
    begin
      if LowerInput.Contains('?') and (Length(Input) > 5) then
      begin
        Result := 'Question';
        Exit;
      end;
    end;
  end;
end;

function TSymbolicEngine.Infer(const Query: string): TFact;
begin
  // Упрощенный вывод - в реальности здесь будет полноценный логический движок
  Result.Subject := '';
  Result.Relation := '';
  Result.Object := '';
  Result.Confidence := 0.0;
end;

procedure TSymbolicEngine.SaveToFile(const Filename: string);
begin
  // Сохранение фактов и правил
end;

procedure TSymbolicEngine.LoadFromFile(const Filename: string);
begin
  // Загрузка фактов и правил
end;

end.

// В AdvancedChatAI.pas
var
  SymbolicEngine: TSymbolicEngine;

procedure Initialize;
begin
  // Существующая инициализация...
  
  // Добавляем символьный движок
  SymbolicEngine := TSymbolicEngine.Create;
  
  // Загружаем базу знаний если есть
  if FileExists('knowledge_base.txt') then
    SymbolicEngine.LoadFromFile('knowledge_base.txt');
end;

procedure EnhancedProcessUserInput;
var
  inputText: ucs4;
  userMessage, ruleResult, finalResponse: string;
  extractedFacts: array of TFact;
  symbolicContext: string;
begin
  // 1. Получаем пользовательский ввод (как раньше)
  UserInput := GetUserInput(POST_FILE, filesList);
  inputText := UserInput.Message;
  userMessage := inputText.ToUTF8.Trim;

  if inputText.Length = 0 then Exit;

  WriteLn('Пользователь: ', userMessage);

  // 2. Символьный анализ
  ruleResult := SymbolicEngine.ExecuteRule(userMessage);
  WriteLn('Символьный анализ: ', ruleResult);

  // 3. Извлекаем факты через трансформер (нейросетевая часть)
  extractedFacts := ExtractFactsWithTransformer(userMessage);
  
  // 4. Добавляем факты в символьную систему
  for I := 0 to High(extractedFacts) do
  begin
    SymbolicEngine.AddFact(extractedFacts[I].Subject, 
                          extractedFacts[I].Relation, 
                          extractedFacts[I].Object,
                          extractedFacts[I].Confidence);
  end;

  // 5. Логический вывод на основе контекста
  symbolicContext := BuildSymbolicContext(ConversationHistory);
  finalResponse := GenerateHybridResponse(userMessage, ruleResult, symbolicContext);

  // 6. Вывод результата
  WriteLn('AI: ', finalResponse);
  UpdateConversationContext('', finalResponse);
end;

function ExtractFactsWithTransformer(const Text: string): array of TFact;
var
  inputMatrix, outputMatrix: TDoubleMatrix;
  entities: TStringArray;
  I: Integer;
begin
  // Используем трансформер для извлечения сущностей и отношений
  inputMatrix := CreateContextEnrichedInput(Text, '');
  ForwardTransformer(TransformerModel, inputMatrix, outputMatrix);
  
  // Преобразуем выход трансформера в факты
  entities := ParseEntitiesFromOutput(outputMatrix);
  
  SetLength(Result, Length(entities) div 3); // Предполагаем формат [субъект, отношение, объект]
  for I := 0 to (Length(entities) div 3) - 1 do
  begin
    Result[I].Subject := entities[I*3];
    Result[I].Relation := entities[I*3+1];
    Result[I].Object := entities[I*3+2];
    Result[I].Confidence := 0.8; // На основе уверенности модели
  end;
end;

function GenerateHybridResponse(const UserMessage, RuleResult, Context: string): string;
begin
  // Комбинируем подходы
  
  // 1. Если символьная система уверена - используем её
  if RuleResult = 'Greeting' then
    Result := 'Здравствуйте! Чем могу помочь?'
  else if RuleResult = 'Farewell' then
    Result := 'До свидания! Рад был пообщаться.'
  else if RuleResult = 'Question' then
  begin
    // Для вопросов используем комбинацию
    if Context.Contains('погод') then
      Result := 'К сожалению, у меня нет доступа к актуальным данным о погоде. '
    else
      Result := 'Интересный вопрос! ';
    
    // Добавляем нейросетевую вариативность
    Result := Result + GenerateTransformerResponse(UserMessage);
  end
  else
    // По умолчанию - нейросеть
    Result := GenerateTransformerResponse(UserMessage);
end;

procedure LearnSymbolicRules(const UserMessage, AIResponse: string);
var
  patterns: TStringArray;
  newRule: string;
begin
  // Анализируем успешные диалоги для извлечения правил
  if ShouldExtractRule(UserMessage, AIResponse) then
  begin
    patterns := ExtractPatterns(UserMessage);
    newRule := BuildRuleFromPatterns(patterns, AIResponse);
    SymbolicEngine.AddRule(newRule, AIResponse, 5);
    
    WriteLn('Добавлено новое правило: ', newRule);
  end;
end;

// SymbolicEngineUnit.pas
unit SymbolicEngineUnit;

{$MODE OBJFPC}{$H+}
{$CODEPAGE UTF8}

interface

uses
  SysUtils, Classes, DataUtils, ucs4unit, ucs4functionsunit, TextEmbeddings;

type
  TFact = record
    Subject: string;
    Relation: string;
    Object: string;
    Confidence: Double;
  end;
  TFactArray = array of TFact;

  TRule = record
    Condition: string; // Логическое выражение
    Action: string;    // Действие/вывод
    Priority: Integer;
    UsageCount: Integer;
  end;
  TRuleArray = array of TRule;

  TSymbolicEngine = class
  private
    FFacts: TFactArray;
    FRules: TRuleArray;
    FWorkingMemory: TStringList;
    
    // Вспомогательные методы для парсинга условий
    function ParseCondition(const Condition: string): TStringArray;
    function EvaluateCondition(const Condition: string; const Input: string): Boolean;
    
  public
    constructor Create;
    destructor Destroy; override;
    
    // Управление фактами
    procedure AddFact(const Subject, Relation, Object: string; Confidence: Double = 1.0);
    function FindFacts(const Subject, Relation, Object: string): TFactArray;
    procedure RemoveFact(Index: Integer);
    
    // Управление правилами
    procedure AddRule(const Condition, Action: string; Priority: Integer = 1);
    function FindMatchingRules(const Input: string): TRuleArray;
    
    // Основные функции
    function ExecuteRule(const Input: string): string;
    function Infer(const Query: string): TFactArray;
    
    // Обучение и извлечение правил
    function ShouldExtractRule(const UserMessage, AIResponse: string): Boolean;
    function ExtractPatterns(const Text: string): TStringArray;
    function BuildRuleFromPatterns(const Patterns: TStringArray; const Response: string): string;
    procedure LearnFromDialogue(const UserMessage, AIResponse: string);
    
    // Сохранение/загрузка
    procedure SaveToFile(const Filename: string);
    procedure LoadFromFile(const Filename: string);
    
    // Утилиты
    function GetStats: string;
    procedure ClearRules;
  end;

// Глобальные функции для работы с текстом
function ContainsAny(const Text: string; const Patterns: array of string): Boolean;
function ExtractKeywords(const Text: string): TStringArray;
function CalculatePatternScore(const Pattern: string): Double;

var
  SymbolicEngine: TSymbolicEngine;

implementation

function ContainsAny(const Text: string; const Patterns: array of string): Boolean;
var
  I: Integer;
  LowerText: string;
begin
  LowerText := UTF8LowerCase(Text);
  for I := 0 to High(Patterns) do
  begin
    if LowerText.Contains(UTF8LowerCase(Patterns[I])) then
      Exit(True);
  end;
  Result := False;
end;

function ExtractKeywords(const Text: string): TStringArray;
var
  tokens: TUC4Array;
  i, count: Integer;
  tokenStr: string;
begin
  SetLength(Result, 0);
  
  // Токенизируем текст
  tokens := TokenizeForNLP(NormalizeForAI(RemovePunctuation(Text)));
  if Length(tokens) = 0 then Exit;
  
  // Фильтруем стоп-слова и короткие токены
  count := 0;
  SetLength(Result, Length(tokens));
  
  for i := 0 to High(tokens) do
  begin
    tokenStr := tokens[i].ToUTF8.Trim;
    
    // Пропускаем короткие слова и стоп-слова
    if (Length(tokenStr) > 2) and 
       (not ContainsAny(tokenStr, ['это', 'что', 'как', 'где', 'когда', 'почему', 'зачем'])) then
    begin
      Result[count] := tokenStr;
      Inc(count);
    end;
  end;
  
  SetLength(Result, count);
end;

function CalculatePatternScore(const Pattern: string): Double;
var
  keywords: TStringArray;
  i: Integer;
begin
  Result := 0.0;
  keywords := ExtractKeywords(Pattern);
  
  // Оцениваем паттерн на основе количества ключевых слов и их значимости
  for i := 0 to High(keywords) do
  begin
    // Простая эвристика: более длинные слова обычно более значимы
    Result := Result + Length(keywords[i]) * 0.1;
    
    // Особо значимые слова
    if ContainsAny(keywords[i], ['погод', 'врем', 'температур', 'градус']) then
      Result := Result + 1.0;
    if ContainsAny(keywords[i], ['имя', 'зовут', 'называ']) then
      Result := Result + 1.0;
    if ContainsAny(keywords[i], ['счет', 'математ', 'числ', 'плюс', 'минус']) then
      Result := Result + 1.5;
  end;
end;

constructor TSymbolicEngine.Create;
begin
  inherited;
  FWorkingMemory := TStringList.Create;
  SetLength(FFacts, 0);
  SetLength(FRules, 0);
  
  // Базовые правила
  AddRule('Contains(Input, "привет") OR Contains(Input, "здравств")', 'Greeting', 10);
  AddRule('Contains(Input, "пока") OR Contains(Input, "до свидан")', 'Farewell', 10);
  AddRule('Contains(Input, "спасибо") OR Contains(Input, "благодар")', 'Thanks', 8);
  AddRule('EndsWith(Input, "?") AND Length(Input) > 3', 'Question', 5);
  AddRule('Contains(Input, "погод")', 'WeatherQuery', 7);
  AddRule('Contains(Input, "имя") OR Contains(Input, "зовут")', 'NameQuery', 6);
  AddRule('Contains(Input, "счет") OR Contains(Input, "посчитай")', 'MathQuery', 9);
end;

destructor TSymbolicEngine.Destroy;
begin
  FWorkingMemory.Free;
  inherited;
end;

procedure TSymbolicEngine.AddFact(const Subject, Relation, Object: string; Confidence: Double);
begin
  SetLength(FFacts, Length(FFacts) + 1);
  with FFacts[High(FFacts)] do
  begin
    Subject := Subject;
    Relation := Relation;
    Object := Object;
    Confidence := Confidence;
  end;
end;

function TSymbolicEngine.FindFacts(const Subject, Relation, Object: string): TFactArray;
var
  i, count: Integer;
begin
  SetLength(Result, 0);
  count := 0;
  
  for i := 0 to High(FFacts) do
  begin
    if ((Subject = '') or (FFacts[i].Subject = Subject)) and
       ((Relation = '') or (FFacts[i].Relation = Relation)) and
       ((Object = '') or (FFacts[i].Object = Object)) then
    begin
      SetLength(Result, count + 1);
      Result[count] := FFacts[i];
      Inc(count);
    end;
  end;
end;

procedure TSymbolicEngine.RemoveFact(Index: Integer);
var
  i: Integer;
begin
  if (Index < 0) or (Index > High(FFacts)) then Exit;
  
  for i := Index to High(FFacts) - 1 do
    FFacts[i] := FFacts[i + 1];
  
  SetLength(FFacts, Length(FFacts) - 1);
end;

procedure TSymbolicEngine.AddRule(const Condition, Action: string; Priority: Integer);
begin
  SetLength(FRules, Length(FRules) + 1);
  with FRules[High(FRules)] do
  begin
    Condition := Condition;
    Action := Action;
    Priority := Priority;
    UsageCount := 0;
  end;
end;

function TSymbolicEngine.ParseCondition(const Condition: string): TStringArray;
begin
  // Простой парсер условий - разбиваем по OR и AND
  SetLength(Result, 0);
  
  if Condition.Contains(' OR ') then
  begin
    SetLength(Result, 2);
    Result[0] := Copy(Condition, 1, Pos(' OR ', Condition) - 1);
    Result[1] := Copy(Condition, Pos(' OR ', Condition) + 4, MaxInt);
  end
  else if Condition.Contains(' AND ') then
  begin
    SetLength(Result, 2);
    Result[0] := Copy(Condition, 1, Pos(' AND ', Condition) - 1);
    Result[1] := Copy(Condition, Pos(' AND ', Condition) + 5, MaxInt);
  end
  else
  begin
    SetLength(Result, 1);
    Result[0] := Condition;
  end;
end;

function TSymbolicEngine.EvaluateCondition(const Condition: string; const Input: string): Boolean;
var
  parts: TStringArray;
  lowerInput: string;
begin
  Result := False;
  lowerInput := UTF8LowerCase(Input);
  
  if Condition.StartsWith('Contains(Input, "') and Condition.EndsWith('")') then
  begin
    // Извлекаем подстроку для поиска
    parts := Condition.Split(['"']);
    if Length(parts) >= 2 then
      Result := lowerInput.Contains(UTF8LowerCase(parts[1]));
  end
  else if Condition.StartsWith('EndsWith(Input, "') and Condition.EndsWith('")') then
  begin
    parts := Condition.Split(['"']);
    if Length(parts) >= 2 then
      Result := lowerInput.EndsWith(UTF8LowerCase(parts[1]));
  end
  else if Condition.StartsWith('StartsWith(Input, "') and Condition.EndsWith('")') then
  begin
    parts := Condition.Split(['"']);
    if Length(parts) >= 2 then
      Result := lowerInput.StartsWith(UTF8LowerCase(parts[1]));
  end
  else if Condition.Contains(' OR ') then
  begin
    parts := ParseCondition(Condition);
    Result := EvaluateCondition(parts[0], Input) or EvaluateCondition(parts[1], Input);
  end
  else if Condition.Contains(' AND ') then
  begin
    parts := ParseCondition(Condition);
    Result := EvaluateCondition(parts[0], Input) and EvaluateCondition(parts[1], Input);
  end;
end;

function TSymbolicEngine.FindMatchingRules(const Input: string): TRuleArray;
var
  i, count: Integer;
begin
  SetLength(Result, 0);
  count := 0;
  
  for i := 0 to High(FRules) do
  begin
    if EvaluateCondition(FRules[i].Condition, Input) then
    begin
      SetLength(Result, count + 1);
      Result[count] := FRules[i];
      Inc(count);
    end;
  end;
end;

function TSymbolicEngine.ExecuteRule(const Input: string): string;
var
  matchingRules: TRuleArray;
  bestRule: TRule;
  i: Integer;
begin
  Result := '';
  matchingRules := FindMatchingRules(Input);
  
  if Length(matchingRules) = 0 then Exit;
  
  // Выбираем правило с наивысшим приоритетом
  bestRule := matchingRules[0];
  for i := 1 to High(matchingRules) do
  begin
    if matchingRules[i].Priority > bestRule.Priority then
      bestRule := matchingRules[i];
  end;
  
  // Обновляем счетчик использования
  for i := 0 to High(FRules) do
  begin
    if FRules[i].Condition = bestRule.Cition then
    begin
      Inc(FRules[i].UsageCount);
      Break;
    end;
  end;
  
  Result := bestRule.Action;
end;

function TSymbolicEngine.Infer(const Query: string): TFactArray;
begin
  // Упрощенный логический вывод
  // В реальной реализации здесь будет полноценный логический движок
  Result := FindFacts('', '', '');
end;

// Реализация недостающих функций

function TSymbolicEngine.ShouldExtractRule(const UserMessage, AIResponse: string): Boolean;
var
  msgScore, responseScore: Double;
begin
  // Решаем, стоит ли извлекать правило из этого диалога
  
  // Критерии для извлечения правил:
  // 1. Сообщение не слишком короткое
  // 2. Ответ не шаблонный
  // 3. Высокая уверенность в качестве диалога
  
  if Length(UserMessage) < 5 then Exit(False);
  if Length(AIResponse) < 3 then Exit(False);
  
  // Оцениваем значимость сообщения
  msgScore := CalculatePatternScore(UserMessage);
  responseScore := CalculatePatternScore(AIResponse);
  
  // Пропускаем простые приветствия и прощания
  if ContainsAny(UserMessage, ['привет', 'пока', 'спасибо']) and 
     ContainsAny(AIResponse, ['Здравствуйте', 'До свидания', 'Пожалуйста']) then
    Exit(False);
  
  // Извлекаем правила для значимых диалогов
  Result := (msgScore > 1.0) and (responseScore > 0.5);
end;

function TSymbolicEngine.ExtractPatterns(const Text: string): TStringArray;
var
  keywords: TStringArray;
  i: Integer;
begin
  SetLength(Result, 0);
  keywords := ExtractKeywords(Text);
  
  // Формируем паттерны на основе ключевых слов
  for i := 0 to High(keywords) do
  begin
    SetLength(Result, Length(Result) + 1);
    
    // Создаем условие для каждого значимого ключевого слова
    if Length(keywords[i]) > 3 then
      Result[High(Result)] := 'Contains(Input, "' + keywords[i] + '")'
    else
      SetLength(Result, Length(Result) - 1); // Удаляем если слово слишком короткое
  end;
end;

function TSymbolicEngine.BuildRuleFromPatterns(const Patterns: TStringArray; const Response: string): string;
var
  condition: string;
  i: Integer;
begin
  if Length(Patterns) = 0 then
  begin
    Result := '';
    Exit;
  end;
  
  // Объединяем паттерны через OR
  condition := Patterns[0];
  for i := 1 to High(Patterns) do
    condition := condition + ' OR ' + Patterns[i];
  
  Result := condition;
end;

procedure TSymbolicEngine.LearnFromDialogue(const UserMessage, AIResponse: string);
var
  patterns: TStringArray;
  newRule: string;
begin
  if not ShouldExtractRule(UserMessage, AIResponse) then Exit;
  
  WriteLn('Символьное обучение: извлекаем правило из диалога');
  WriteLn('  Вход: ', UserMessage);
  WriteLn('  Выход: ', AIResponse);
  
  patterns := ExtractPatterns(UserMessage);
  if Length(patterns) = 0 then Exit;
  
  newRule := BuildRuleFromPatterns(patterns, AIResponse);
  if newRule <> '' then
  begin
    AddRule(newRule, AIResponse, 3); // Низкий приоритет для изученных правил
    WriteLn('  Добавлено правило: ', newRule, ' -> ', AIResponse);
  end;
end;

procedure TSymbolicEngine.SaveToFile(const Filename: string);
var
  F: TextFile;
  i: Integer;
begin
  AssignFile(F, Filename);
  try
    Rewrite(F);
    
    // Сохраняем факты
    WriteLn(F, '[Facts]');
    for i := 0 to High(FFacts) do
    begin
      WriteLn(F, FFacts[i].Subject, '|', FFacts[i].Relation, '|', 
              FFacts[i].Object, '|', FFacts[i].Confidence:0:4);
    end;
    
    // Сохраняем правила
    WriteLn(F, '[Rules]');
    for i := 0 to High(FRules) do
    begin
      WriteLn(F, FRules[i].Condition, '|', FRules[i].Action, '|', 
              FRules[i].Priority, '|', FRules[i].UsageCount);
    end;
    
  finally
    CloseFile(F);
  end;
end;

procedure TSymbolicEngine.LoadFromFile(const Filename: string);
var
  F: TextFile;
  Line: string;
  Parts: TStringArray;
  section: string;
begin
  if not FileExists(Filename) then Exit;
  
  AssignFile(F, Filename);
  try
    Reset(F);
    section := '';
    
    while not Eof(F) do
    begin
      ReadLn(F, Line);
      Line := Trim(Line);
      
      if Line = '' then Continue;
      
      if Line = '[Facts]' then
        section := 'facts'
      else if Line = '[Rules]' then
        section := 'rules'
      else if section = 'facts' then
      begin
        Parts := Line.Split(['|']);
        if Length(Parts) >= 4 then
        begin
          AddFact(Parts[0], Parts[1], Parts[2], StrToFloatDef(Parts[3], 1.0));
        end;
      end
      else if section = 'rules' then
      begin
        Parts := Line.Split(['|']);
        if Length(Parts) >= 3 then
        begin
          AddRule(Parts[0], Parts[1], StrToIntDef(Parts[2], 1));
        end;
      end;
    end;
    
  finally
    CloseFile(F);
  end;
end;

function TSymbolicEngine.GetStats: string;
begin
  Result := Format('Фактов: %d, Правил: %d', [Length(FFacts), Length(FRules)]);
end;

procedure TSymbolicEngine.ClearRules;
begin
  SetLength(FRules, 0);
end;

initialization
  SymbolicEngine := TSymbolicEngine.Create;

finalization
  SymbolicEngine.Free;

end.

// В AdvancedChatAI.pas - добавьте в секцию uses:
uses
  ..., SymbolicEngineUnit;

// В процедуре Initialize добавьте:
procedure Initialize;
begin
  // Существующий код...
  
  // Инициализация символьного движка
  WriteLn('Инициализация символьного движка...');
  
  // Загружаем базу знаний если есть
  if FileExists('symbolic_knowledge.txt') then
  begin
    SymbolicEngine.LoadFromFile('symbolic_knowledge.txt');
    WriteLn('База знаний загружена: ', SymbolicEngine.GetStats);
  end;
end;

// Новая улучшенная версия ProcessUserInput:
procedure EnhancedProcessUserInput;
var
  inputText: ucs4;
  userMessage, symbolicResult, finalResponse: string;
  filesList: TStringList;
  inputMatrix, outputMatrix: TDoubleMatrix;
begin
  filesList := TStringList.Create;
  try
    // 1. Получаем пользовательский ввод
    UserInput := GetUserInput(POST_FILE, filesList);
    inputText := UserInput.Message;
    userMessage := inputText.ToUTF8.Trim;

    if inputText.Length = 0 then begin
      WriteLn('Пустое сообщение, пропускаем');
      Exit;
    end;

    WriteLn('Пользователь: ', userMessage);
    LastUserMessage := userMessage;

    // 2. Добавляем сообщение в историю
    UpdateConversationContext(userMessage, '');

    // 3. Символьный анализ
    symbolicResult := SymbolicEngine.ExecuteRule(userMessage);
    
    if symbolicResult <> '' then
    begin
      WriteLn('Символьная система: ', symbolicResult);
      
      // Генерируем ответ на основе символьного результата
      case symbolicResult of
        'Greeting': 
          finalResponse := 'Здравствуйте! Рад вас видеть. Чем могу помочь?';
        'Farewell': 
          finalResponse := 'До свидания! Буду рад пообщаться снова.';
        'Thanks':
          finalResponse := 'Пожалуйста! Обращайтесь, если понадобится помощь.';
        'Question':
          finalResponse := 'Интересный вопрос! ' + GenerateTransformerResponse(userMessage);
        'WeatherQuery':
          finalResponse := 'К сожалению, у меня нет доступа к актуальным данным о погоде. ' +
                          'Но могу обсудить погоду в общем смысле!';
        'NameQuery':
          finalResponse := 'Я - чат-бот с искусственным интеллектом. ' +
                          'Можно просто называть меня "помощник".';
        'MathQuery':
          finalResponse := 'Я могу помочь с математическими вопросами! ' +
                          'Задайте конкретный пример для расчета.';
        else
          finalResponse := GenerateTransformerResponse(userMessage);
      end;
    end
    else
    begin
      // 4. Если символьная система не нашла правила, используем трансформер
      WriteLn('Символьная система: правило не найдено, используем трансформер');
      inputMatrix := CreateContextEnrichedInput(inputText, GetConversationContext);
      ForwardTransformer(TransformerModel, inputMatrix, outputMatrix);
      finalResponse := ResponseGenerator.GenerateResponse(outputMatrix, GetConversationContext, userMessage);
    end;

    // 5. Выводим ответ и добавляем в историю
    WriteLn('AI: ', finalResponse);
    UpdateConversationContext('', finalResponse);

    // 6. Обучение на успешном диалоге
    if ShouldSaveForTraining(userMessage, finalResponse) then
    begin
      LearnFromConversation(userMessage, finalResponse);
      SymbolicEngine.LearnFromDialogue(userMessage, finalResponse);
      
      // Сохраняем базу знаний
      SymbolicEngine.SaveToFile('symbolic_knowledge.txt');
    end;

  except
    on E: Exception do
    begin
      WriteLn('Ошибка: ', E.Message);
      finalResponse := 'Извините, произошла техническая ошибка. Попробуйте еще раз.';
      WriteLn('AI: ', finalResponse);
    end;
  end;
  filesList.Free;
end;

// SymbolicEngineUnit.pas - добавляем новые функции

// В интерфейсную часть добавляем:
function ParseEntitiesFromOutput(const OutputMatrix: TDoubleMatrix): TStringArray;
function BuildSymbolicContext(const History: TStringList): string;

// В реализацию добавляем:

function ParseEntitiesFromOutput(const OutputMatrix: TDoubleMatrix): TStringArray;
var
  i, j, entityCount: Integer;
  maxVal: Double;
  maxIndex: Integer;
  entities: array of string;
begin
  SetLength(Result, 0);
  if (Length(OutputMatrix) = 0) or (Length(OutputMatrix[0]) = 0) then Exit;
  
  // Упрощенная реализация - в реальности здесь будет полноценное извлечение сущностей
  // Сейчас просто возвращаем пустой массив для демонстрации
  
  // В реальной реализации здесь будет:
  // 1. Классификация токенов на сущности (PER, ORG, LOC и т.д.)
  // 2. Извлечение отношений между сущностями
  // 3. Формирование фактов
  
  WriteLn('ParseEntitiesFromOutput: извлечение сущностей из матрицы ', 
          Length(OutputMatrix), 'x', Length(OutputMatrix[0]));
  
  // Заглушка - возвращаем пустой массив
  // В рабочей версии здесь будет реальное извлечение сущностей
end;

function BuildSymbolicContext(const History: TStringList): string;
var
  i: Integer;
  contextFacts: TStringList;
  recentMessages: string;
  fact: TFact;
  facts: TFactArray;
begin
  contextFacts := TStringList.Create;
  try
    // Собираем последние сообщения для контекста
    recentMessages := '';
    for i := Max(0, History.Count - 4) to History.Count - 1 do
    begin
      if i >= 0 then
        recentMessages := recentMessages + History[i] + ' ';
    end;
    
    // Извлекаем факты из истории
    facts := SymbolicEngine.FindFacts('', '', '');
    
    // Формируем контекст в виде строки
    Result := 'Recent: ' + recentMessages.Trim;
    
    if Length(facts) > 0 then
    begin
      Result := Result + ' | Facts: ';
      for i := 0 to Min(High(facts), 2) do // Берем только 3 последних факта
      begin
        Result := Result + facts[i].Subject + '-' + facts[i].Relation + '-' + 
                 facts[i].Object + '; ';
      end;
    end;
    
    // Добавляем информацию о текущих правилах
    Result := Result + ' | Rules: ' + IntToStr(Length(SymbolicEngine.FRules));
    
  finally
    contextFacts.Free;
  end;
end;

// Также обновим функцию ExtractFactsWithTransformer в AdvancedChatAI.pas:
function ExtractFactsWithTransformer(const Text: string): TFactArray;
var
  inputMatrix, outputMatrix: TDoubleMatrix;
  entities: TStringArray;
  i, factCount: Integer;
  tokens: TUC4Array;
begin
  SetLength(Result, 0);
  
  // Упрощенная реализация - используем токенизацию и эвристики
  // В реальной реализации здесь будет полноценное извлечение фактов
  
  try
    // Токенизируем текст
    tokens := TokenizeForNLP(NormalizeForAI(RemovePunctuation(Text)));
    
    factCount := 0;
    SetLength(Result, Length(tokens) div 2); // Оценка количества возможных фактов
    
    // Простая эвристика для извлечения фактов
    for i := 0 to High(tokens) - 1 do
    begin
      // Если два соседних токена могут образовывать факт
      if (tokens[i].Length > 2) and (tokens[i + 1].Length > 2) then
      begin
        // Простая эвристика: если первый токен похож на субъект, второй на объект
        Result[factCount].Subject := tokens[i].ToUTF8;
        Result[factCount].Relation := 'is_related_to'; // Упрощенное отношение
        Result[factCount].Object := tokens[i + 1].ToUTF8;
        Result[factCount].Confidence := 0.3; // Низкая уверенность для эвристики
        
        Inc(factCount);
      end;
    end;
    
    SetLength(Result, factCount);
    
    WriteLn('Извлечено фактов: ', factCount);
    
  except
    on E: Exception do
    begin
      WriteLn('Ошибка извлечения фактов: ', E.Message);
      SetLength(Result, 0);
    end;
  end;
end;

// ContextProcessing.pas
unit ContextProcessing;

{$MODE OBJFPC}{$H+}
{$CODEPAGE UTF8}

interface

uses
  SysUtils, Classes, DataUtils, MatrixOps, ucs4unit, ucs4functionsunit, 
  TextEmbeddings, SymbolicEngineUnit;

// Функции для обработки контекста
function BuildEnhancedContext(const History: TStringList; const CurrentInput: string): string;
function ExtractEntitiesFromText(const Text: string): TStringArray;
function AnalyzeConversationTopic(const History: TStringList): string;
function ShouldUpdateSymbolicFacts(const UserMessage, AIResponse: string): Boolean;

// Функции для работы с матрицами вывода
function DetectEntitiesInOutput(const OutputMatrix: TDoubleMatrix; const Vocabulary: TStringList): TStringArray;
function ExtractRelationsFromOutput(const OutputMatrix: TDoubleMatrix): TStringArray;

implementation

function BuildEnhancedContext(const History: TStringList; const CurrentInput: string): string;
var
  i: Integer;
  topic, entities: string;
  recentContext: TStringList;
begin
  recentContext := TStringList.Create;
  try
    // Анализируем тему разговора
    topic := AnalyzeConversationTopic(History);
    
    // Собираем последние 3 сообщения
    for i := Max(0, History.Count - 6) to History.Count - 1 do
    begin
      if (i >= 0) and (i < History.Count) then
        recentContext.Add(History[i]);
    end;
    
    // Извлекаем сущности из текущего ввода
    entities := '';
    for i := 0 to High(ExtractEntitiesFromText(CurrentInput)) do
    begin
      if i > 0 then entities := entities + ', ';
      entities := entities + ExtractEntitiesFromText(CurrentInput)[i];
    end;
    
    // Формируем расширенный контекст
    Result := 'Тема: ' + topic + ' | ';
    Result := Result + 'Сущности: ' + entities + ' | ';
    Result := Result + 'История: ' + recentContext.Text;
    
  finally
    recentContext.Free;
  end;
end;

function ExtractEntitiesFromText(const Text: string): TStringArray;
var
  tokens: TUC4Array;
  i, count: Integer;
  tokenStr: string;
begin
  SetLength(Result, 0);
  tokens := TokenizeForNLP(NormalizeForAI(RemovePunctuation(Text)));
  
  if Length(tokens) = 0 then Exit;
  
  count := 0;
  SetLength(Result, Length(tokens));
  
  // Простая эвристика для идентификации сущностей
  for i := 0 to High(tokens) do
  begin
    tokenStr := tokens[i].ToUTF8;
    
    // Определяем тип сущности по простым правилам
    if (Length(tokenStr) >= 3) then
    begin
      // Имена (начинаются с заглавной буквы в оригинале)
      if (tokenStr = UTF8UpperCase(tokenStr)) and (Length(tokenStr) > 1) then
      begin
        Result[count] := 'PER:' + tokenStr;
        Inc(count);
      end
      // Числа
      else if TryStrToFloat(tokenStr, dummyFloat) then
      begin
        Result[count] := 'NUM:' + tokenStr;
        Inc(count);
      end
      // Длинные слова могут быть концепциями
      else if (Length(tokenStr) >= 5) then
      begin
        Result[count] := 'CONCEPT:' + tokenStr;
        Inc(count);
      end;
    end;
  end;
  
  SetLength(Result, count);
end;

function AnalyzeConversationTopic(const History: TStringList): string;
var
  i: Integer;
  allText, lowerText: string;
  topicScores: array of record
    Topic: string;
    Score: Integer;
  end;
begin
  if History.Count = 0 then
    Exit('general');
    
  // Собираем весь текст истории
  allText := '';
  for i := 0 to History.Count - 1 do
    allText := allText + ' ' + History[i];
    
  lowerText := UTF8LowerCase(allText);
  
  // Простой анализ темы по ключевым словам
  SetLength(topicScores, 5);
  topicScores[0].Topic := 'погода';
  topicScores[0].Score := 0;
  topicScores[1].Topic := 'имя';
  topicScores[1].Score := 0;
  topicScores[2].Topic := 'математика';
  topicScores[2].Score := 0;
  topicScores[3].Topic := 'технологии';
  topicScores[3].Score := 0;
  topicScores[4].Topic := 'общение';
  topicScores[4].Score := 0;
  
  // Подсчитываем упоминания тем
  if lowerText.Contains('погод') then Inc(topicScores[0].Score, 2);
  if lowerText.Contains('дожд') or lowerText.Contains('солн') then Inc(topicScores[0].Score);
  
  if lowerText.Contains('имя') or lowerText.Contains('зовут') then Inc(topicScores[1].Score, 3);
  
  if lowerText.Contains('счет') or lowerText.Contains('числ') then Inc(topicScores[2].Score, 2);
  if lowerText.Contains('плюс') or lowerText.Contains('минус') then Inc(topicScores[2].Score);
  
  if lowerText.Contains('компьютер') or lowerText.Contains('програм') then Inc(topicScores[3].Score, 2);
  
  // Базовая тема для общих разговоров
  topicScores[4].Score := 1;
  
  // Находим тему с максимальным счетом
  Result := topicScores[0].Topic;
  for i := 1 to High(topicScores) do
  begin
    if topicScores[i].Score > topicScores[0].Score then
    begin
      Result := topicScores[i].Topic;
      topicScores[0].Score := topicScores[i].Score;
    end;
  end;
end;

function ShouldUpdateSymbolicFacts(const UserMessage, AIResponse: string): Boolean;
begin
  // Решаем, нужно ли обновлять символьные факты на основе диалога
  Result := (Length(UserMessage) > 10) and 
            (not UserMessage.Contains('?')) and
            (AIResponse.Length > 5) and
            (not ContainsAny(UserMessage, ['привет', 'пока', 'спасибо']));
end;

function DetectEntitiesInOutput(const OutputMatrix: TDoubleMatrix; const Vocabulary: TStringList): TStringArray;
var
  i, j: Integer;
  maxScore: Double;
  bestIndex: Integer;
begin
  SetLength(Result, 0);
  
  if (Length(OutputMatrix) = 0) or (Vocabulary = nil) then Exit;
  
  // Упрощенная детекция сущностей - находим наиболее вероятные токены
  for i := 0 to High(OutputMatrix) do
  begin
    if Length(OutputMatrix[i]) > 0 then
    begin
      maxScore := OutputMatrix[i][0];
      bestIndex := 0;
      
      for j := 1 to High(OutputMatrix[i]) do
      begin
        if OutputMatrix[i][j] > maxScore then
        begin
          maxScore := OutputMatrix[i][j];
          bestIndex := j;
        end;
      end;
      
      // Если уверенность достаточно высока, добавляем сущность
      if (maxScore > 0.3) and (bestIndex < Vocabulary.Count) then
      begin
        SetLength(Result, Length(Result) + 1);
        Result[High(Result)] := Vocabulary[bestIndex];
      end;
    end;
  end;
end;

function ExtractRelationsFromOutput(const OutputMatrix: TDoubleMatrix): TStringArray;
begin
  SetLength(Result, 0);
  // Заглушка для извлечения отношений
  // В реальной реализации здесь будет анализ структуры выходной матрицы
  // для обнаружения отношений между сущностями
end;

end.

// В AdvancedChatAI.pas - добавляем в uses:
uses
  ..., SymbolicEngineUnit, ContextProcessing;

// Заменяем старые функции на новые:

function ParseEntitiesFromOutput(const OutputMatrix: TDoubleMatrix): TStringArray;
begin
  // Используем функцию из ContextProcessing
  Result := DetectEntitiesInOutput(OutputMatrix, WordEmbeddings.FVocab);
end;

function BuildSymbolicContext(const History: TStringList): string;
begin
  // Используем функцию из ContextProcessing
  Result := BuildEnhancedContext(History, LastUserMessage);
end;

// Обновляем EnhancedProcessUserInput для использования расширенного контекста:
procedure EnhancedProcessUserInput;
var
  inputText: ucs4;
  userMessage, symbolicResult, finalResponse, enhancedContext: string;
  filesList: TStringList;
  inputMatrix, outputMatrix: TDoubleMatrix;
  extractedFacts: TFactArray;
  i: Integer;
begin
  filesList := TStringList.Create;
  try
    // 1. Получаем пользовательский ввод
    UserInput := GetUserInput(POST_FILE, filesList);
    inputText := UserInput.Message;
    userMessage := inputText.ToUTF8.Trim;

    if inputText.Length = 0 then begin
      WriteLn('Пустое сообщение, пропускаем');
      Exit;
    end;

    WriteLn('Пользователь: ', userMessage);
    LastUserMessage := userMessage;

    // 2. Добавляем сообщение в историю
    UpdateConversationContext(userMessage, '');

    // 3. Строим расширенный контекст
    enhancedContext := BuildSymbolicContext(ConversationHistory);
    WriteLn('Расширенный контекст: ', Copy(enhancedContext, 1, 100), '...');

    // 4. Символьный анализ
    symbolicResult := SymbolicEngine.ExecuteRule(userMessage);
    
    if symbolicResult <> '' then
    begin
      WriteLn('Символьная система: ', symbolicResult);
      finalResponse := GenerateResponseFromSymbolicSystem(symbolicResult, userMessage, enhancedContext);
    end
    else
    begin
      // 5. Если символьная система не нашла правила, используем трансформер
      WriteLn('Символьная система: правило не найдено, используем трансформер');
      inputMatrix := CreateContextEnrichedInput(inputText, enhancedContext);
      ForwardTransformer(TransformerModel, inputMatrix, outputMatrix);
      finalResponse := ResponseGenerator.GenerateResponse(outputMatrix, enhancedContext, userMessage);
    end;

    // 6. Извлекаем и сохраняем факты
    extractedFacts := ExtractFactsWithTransformer(userMessage);
    for i := 0 to High(extractedFacts) do
    begin
      if extractedFacts[i].Confidence > 0.5 then // Сохраняем только уверенные факты
      begin
        SymbolicEngine.AddFact(extractedFacts[i].Subject, 
                              extractedFacts[i].Relation, 
                              extractedFacts[i].Object,
                              extractedFacts[i].Confidence);
      end;
    end;

    // 7. Выводим ответ и добавляем в историю
    WriteLn('AI: ', finalResponse);
    UpdateConversationContext('', finalResponse);

    // 8. Обучение на успешном диалоге
    if ShouldSaveForTraining(userMessage, finalResponse) then
    begin
      LearnFromConversation(userMessage, finalResponse);
      SymbolicEngine.LearnFromDialogue(userMessage, finalResponse);
      
      // Сохраняем базу знаний
      SymbolicEngine.SaveToFile('symbolic_knowledge.txt');
      WriteLn('Символьные знания сохранены');
    end;

  except
    on E: Exception do
    begin
      WriteLn('Ошибка в EnhancedProcessUserInput: ', E.Message);
      finalResponse := 'Извините, произошла техническая ошибка. Попробуйте еще раз.';
      WriteLn('AI: ', finalResponse);
    end;
  end;
  filesList.Free;
end;

// Добавляем вспомогательную функцию:
function GenerateResponseFromSymbolicSystem(const SymbolicResult, UserMessage, Context: string): string;
begin
  // Генерируем ответ на основе символьного результата и контекста
  case SymbolicResult of
    'Greeting': 
      begin
        if Context.Contains('ранее') then
          Result := 'Снова здравствуйте! Чем могу помочь?'
        else
          Result := 'Здравствуйте! Рад вас видеть. Чем могу помочь?';
      end;
    'Farewell': 
      Result := 'До свидания! Буду рад пообщаться снова.';
    'Thanks':
      Result := 'Пожалуйста! Обращайтесь, если понадобится помощь.';
    'Question':
      begin
        if Context.Contains('погод') then
          Result := 'Относительно погоды: ' + GenerateTransformerResponse(UserMessage)
        else if Context.Contains('математик') then
          Result := 'Для математического вопроса: ' + GenerateTransformerResponse(UserMessage)
        else
          Result := 'Интересный вопрос! ' + GenerateTransformerResponse(UserMessage);
      end;
    'WeatherQuery':
      Result := 'К сожалению, у меня нет доступа к актуальным данным о погоде. ' +
                'Но могу обсудить погоду в общем смысле!';
    'NameQuery':
      Result := 'Я - чат-бот с искусственным интеллектом. ' +
                'Можно просто называть меня "помощник".';
    'MathQuery':
      Result := 'Я могу помочь с математическими вопросами! ' +
                'Задайте конкретный пример для расчета.';
    else
      Result := GenerateTransformerResponse(UserMessage);
  end;
end;

// В ContextProcessing.pas исправим ExtractEntitiesFromText:
function ExtractEntitiesFromText(const Text: string): TStringArray;
var
  tokens: TUC4Array;
  i, count: Integer;
  tokenStr, cleanToken: string;
begin
  SetLength(Result, 0);
  if Text = '' then Exit;
  
  // Токенизируем оригинальный текст, а не обработанный
  tokens := TokenizeForNLP(Text); // Убрали NormalizeForAI и RemovePunctuation
  
  if Length(tokens) = 0 then Exit;
  
  count := 0;
  SetLength(Result, Length(tokens));
  
  for i := 0 to High(tokens) do
  begin
    tokenStr := tokens[i].ToUTF8;
    cleanToken := UTF8LowerCase(tokenStr.Trim);
    
    // Более качественная идентификация сущностей
    if (Length(cleanToken) >= 2) then
    begin
      // Географические названия (эвристика)
      if (Length(cleanToken) >= 4) and 
         (ContainsAny(cleanToken, ['москв', 'санкт', 'петербург', 'росси', 'город'])) then
      begin
        Result[count] := 'LOC:' + tokenStr;
        Inc(count);
      end
      // Вопросы
      else if ContainsAny(cleanToken, ['где', 'когда', 'почему', 'как', 'что']) then
      begin
        Result[count] := 'QUESTION:' + tokenStr;
        Inc(count);
      end
      // Местоимения и указатели
      else if ContainsAny(cleanToken, ['мы', 'вы', 'они', 'я', 'ты', 'это', 'тот']) then
      begin
        Result[count] := 'PRON:' + tokenStr;
        Inc(count);
      end
      // Длинные слова - вероятно концепции
      else if (Length(cleanToken) >= 5) and 
              (not ContainsAny(cleanToken, ['нормальн', 'интересн', 'продолжайте'])) then
      begin
        Result[count] := 'CONCEPT:' + tokenStr;
        Inc(count);
      end;
    end;
  end;
  
  SetLength(Result, count);
end;

// В SymbolicEngineUnit.pas добавим больше базовых правил:
constructor TSymbolicEngine.Create;
begin
  // ... существующий код ...
  
  // Добавляем больше конкретных правил
  AddRule('Contains(Input, "где") AND Contains(Input, "мы")', 'LocationQuery', 8);
  AddRule('Contains(Input, "москв") OR Contains(Input, "питер") OR Contains(Input, "город")', 'CityQuery', 7);
  AddRule('Contains(Input, "нормальн") OR Contains(Input, "хорош") OR Contains(Input, "отличн")', 'PositiveState', 6);
  AddRule('StartsWith(Input, "мы ") AND Length(Input) > 5', 'WeStatement', 5);
end;

// В ContextProcessing.pas улучшим ExtractFactsWithTransformer:
function ExtractFactsWithTransformer(const Text: string): TFactArray;
var
  tokens: TUC4Array;
  i, factCount: Integer;
  lowerText: string;
begin
  SetLength(Result, 0);
  if Text = '' then Exit;
  
  lowerText := UTF8LowerCase(Text);
  tokens := TokenizeForNLP(Text);
  
  factCount := 0;
  SetLength(Result, 2); // Максимум 2 факта из короткого сообщения
  
  // Определенные паттерны для извлечения фактов
  if ContainsAny(lowerText, ['москв', 'питер', 'город']) then
  begin
    Result[factCount].Subject := 'мы';
    Result[factCount].Relation := 'находится_в';
    
    if lowerText.Contains('москв') then
      Result[factCount].Object := 'Москва'
    else if lowerText.Contains('питер') then
      Result[factCount].Object := 'Санкт-Петербург'
    else
      Result[factCount].Object := 'городе';
      
    Result[factCount].Confidence := 0.8;
    Inc(factCount);
  end;
  
  if lowerText.Contains('нормальн') or lowerText.Contains('хорош') then
  begin
    Result[factCount].Subject := 'состояние';
    Result[factCount].Relation := 'является';
    Result[factCount].Object := 'хорошим';
    Result[factCount].Confidence := 0.7;
    Inc(factCount);
  end;
  
  SetLength(Result, factCount);
  WriteLn('Извлечено фактов: ', factCount);
end;

// В ContextProcessing.pas улучшим BuildEnhancedContext:
function BuildEnhancedContext(const History: TStringList; const CurrentInput: string): string;
var
  i: Integer;
  topic, entities, simpleContext: string;
  entityList: TStringArray;
begin
  // Упрощаем контекст для избежания проблем с токенизацией
  simpleContext := '';
  
  // Берем только последние 2 сообщения
  for i := Max(0, History.Count - 4) to History.Count - 1 do
  begin
    if (i >= 0) and (i < History.Count) then
    begin
      // Берем только первые 3 слова из каждого сообщения
      simpleContext := simpleContext + ' ' + Copy(History[i], 1, 30);
    end;
  end;
  
  // Извлекаем сущности более аккуратно
  entityList := ExtractEntitiesFromText(CurrentInput);
  entities := '';
  for i := 0 to High(entityList) do
  begin
    if i > 0 then entities := entities + ' ';
    // Берем только само слово, без тега
    entities := entities + Copy(entityList[i], Pos(':', entityList[i]) + 1, MaxInt);
  end;
  
  // Анализируем тему
  topic := AnalyzeConversationTopic(History);
  
  // Формируем компактный контекст
  Result := 'Т:' + topic + ' С:' + entities + ' И:' + simpleContext.Trim;
  Result := Copy(Result, 1, 100); // Ограничиваем длину
end;

// В AdvancedChatAI.pas добавим отладочную информацию:
procedure EnhancedProcessUserInput;
begin
  // ... существующий код ...
  
  WriteLn('=== ОТЛАДКА СИМВОЛЬНОЙ СИСТЕМЫ ===');
  WriteLn('Пользователь: ', userMessage);
  WriteLn('Символьный результат: ', symbolicResult);
  WriteLn('Контекст: ', Copy(enhancedContext, 1, 80));
  WriteLn('=== КОНЕЦ ОТЛАДКИ ===');
  
  // ... остальной код ...
end;

// В SymbolicEngineUnit.pas улучшим ShouldExtractRule:
function TSymbolicEngine.ShouldExtractRule(const UserMessage, AIResponse: string): Boolean;
var
  msgScore: Double;
  lowerMsg, lowerResp: string;
begin
  if Length(UserMessage) < 3 then Exit(False);
  if Length(AIResponse) < 3 then Exit(False);
  
  lowerMsg := UTF8LowerCase(UserMessage);
  lowerResp := UTF8LowerCase(AIResponse);
  
  // Не извлекаем правила для:
  // - Очень общих ответов
  if ContainsAny(lowerResp, ['что вы думаете', 'продолжайте', 'интересно']) then
    Exit(False);
    
  // - Ответов с вопросами
  if lowerResp.Contains('?') then
    Exit(False);
    
  // - Коротких формальных ответов  
  if ContainsAny(lowerResp, ['здравствуйте', 'до свидания', 'пожалуйста']) then
    Exit(False);
  
  // Оцениваем значимость сообщения
  msgScore := CalculatePatternScore(UserMessage);
  
  // Извлекаем правила только для значимых паттернов
  Result := (msgScore > 0.8) and 
            (Length(UserMessage) > 4) and
            (not UserMessage.EndsWith('?')) and
            (not ContainsAny(lowerMsg, ['привет', 'пока', 'спасибо']));
end;